﻿using System.Text;
using System.Text.RegularExpressions;

public class ValidationHelper
{
    private static readonly Regex RegNumber = new Regex("^[0-9]+$");
    private static readonly Regex RegNumberSign = new Regex("^[+-]?[0-9]+$");
    private static readonly Regex RegDecimal = new Regex("^[0-9]+[.]?[0-9]+$");
    private static readonly Regex RegDecimalSign = new Regex("^[+-]?[0-9]+[.]?[0-9]+$"); //等价于^[+-]?\d+[.]?\d+$
    private static readonly Regex RegEmail = new Regex(@"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$");
    //w 英文字母或数字的字符串，和 [a-zA-Z0-9] 语法一样
    private static readonly Regex RegCHZN = new Regex("[\u4e00-\u9fa5]");

    #region 用户名密码格式
    /// <summary>
    /// 返回字符串真实长度, 1个汉字长度为2
    /// </summary>
    /// <param name="stringValue">字符串</param>
    /// <returns>字符长度</returns>
    public static int GetStringLength(string stringValue)
    {
        return Encoding.Default.GetBytes(stringValue).Length;
    }

    /// <summary>
    /// 检测用户名格式是否有效
    /// </summary>
    /// <param name="userName">用户名</param>
    /// <returns>返回值</returns>
    public static bool IsValidUserName(string userName)
    {
        int userNameLength = GetStringLength(userName);
        if (userNameLength >= 4 && userNameLength <= 20 &&
            Regex.IsMatch(userName, @"^([\u4e00-\u9fa5A-Za-z_0-9]{0,})$"))
        {
            // 判断用户名的长度（4-20个字符）及内容（只能是汉字、字母、下划线、数字）是否合法
            return true;
        }
        return false;
    }

    /// <summary>
    /// 密码有效性
    /// </summary>
    /// <param name="password">密码</param>
    /// <returns>返回值</returns>
    public static bool IsValidPassword(string password)
    {
        return Regex.IsMatch(password, @"^[A-Za-z_0-9]{6,16}$");
    }

    #endregion

    #region 数字字符串检查
    /// <summary>
    /// int有效性
    /// </summary>
    /// <param name="val">字符串</param>
    /// <returns>返回值</returns>
    public static bool IsValidInt(string val)
    {
        return Regex.IsMatch(val, @"^[1-9]\d*\.?[0]*$");
    }

    /// <summary>
    /// 是否数字字符串
    /// </summary>
    /// <param name="inputData">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsNumber(string inputData)
    {
        Match m = RegNumber.Match(inputData);
        return m.Success;
    }

    /// <summary>
    /// 是否数字字符串 可带正负号
    /// </summary>
    /// <param name="inputData">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsNumberSign(string inputData)
    {
        Match m = RegNumberSign.Match(inputData);
        return m.Success;
    }

    /// <summary>
    /// 是否是浮点数
    /// </summary>
    /// <param name="inputData">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsDecimal(string inputData)
    {
        Match m = RegDecimal.Match(inputData);
        return m.Success;
    }

    /// <summary>
    /// 是否是浮点数 可带正负号
    /// </summary>
    /// <param name="inputData">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsDecimalSign(string inputData)
    {
        Match m = RegDecimalSign.Match(inputData);
        return m.Success;
    }
    #endregion

    #region 用指定的替换字符串替换成整数
    ///<summary>
    ///JudgeIsInteger
    ///用指定的替换字符串替换成整数
    ///</summary>
    ///<param name="strNumber">要替换字符串</param>
    ///<returns name="string">替换结果</returns>
    public static string RegexReplaceInteger(string strNumber)
    {
        return Regex.Replace(strNumber, @"[^0-9]", string.Empty);
    }
    #endregion

    #region 过滤SQL关键字
    /// <summary>
    /// 过滤SQL关键字
    /// </summary>
    /// <param name="_sWord">被检查的字符串</param>
    /// <returns></returns>
    public static string ReplaceSQLKeyWord(string str)
    {
        str = Regex.Replace(str.ToLower(), @"select|insert|exists|delete|script|<script>|chr|alter|where|like|union|join|set|declare|from|count\(|drop table|update|truncate|asc\(|mid\(|char\(|xp_cmdshell|exec  master|netlocalgroup administrators|net user|""|and| *|-|'", "", RegexOptions.IgnoreCase);
        str = Regex.Replace(str, @"<[^>]*?>|</[^>]*?>", "", RegexOptions.IgnoreCase);
        str = str.Replace("'", "").Replace("\"", "").Replace("-", "");
        return str;
    }
    #endregion

    #region 中文检测
    /// <summary>
    /// 判断字符是否全角
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static bool JudgeStrIsCh(string str)
    {
        //全角
        if (Regex.IsMatch(str, @"[^\u0000-\u00ff]+"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    /// <summary>
    /// 检测是否有中文字符
    /// </summary>
    /// <param name="inputData">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsHasCHZN(string inputData)
    {
        Match m = RegCHZN.Match(inputData);
        return m.Success;
    }

    /// <summary> 
    /// 检测含有中文字符串的实际长度 
    /// </summary>
    /// <param name="inputData">输入字符串</param>
    /// <returns>返回值</returns>
    public static int GetCHZNLength(string inputData)
    {
        ASCIIEncoding n = new ASCIIEncoding();
        byte[] bytes = n.GetBytes(inputData);

        int length = 0; // l 为字符串之实际长度 
        for (int i = 0; i <= bytes.Length - 1; i++)
        {
            if (bytes[i] == 63) //判断是否为汉字或全脚符号 
            {
                length++;
            }
            length++;
        }
        return length;
    }
    #endregion

    #region 常用格式
    /// <summary>
    /// 验证身份证是否合法  15 和  18位两种
    /// </summary>
    /// <param name="idCard">要验证的身份证</param>
    /// <returns>返回值</returns>
    public static bool IsIdCard(string idCard)
    {
        if (string.IsNullOrEmpty(idCard))
        {
            return false;
        }

        if (idCard.Length == 15)
        {
            return Regex.IsMatch(idCard, @"^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$");
        }
        if (idCard.Length == 18)
        {
            return Regex.IsMatch(idCard,
                                 @"^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])((\d{4})|\d{3}[A-Z])$",
                                 RegexOptions.IgnoreCase);
        }
        return false;
    }

    /// <summary>
    /// 是否是邮件地址
    /// </summary>
    /// <param name="inputData">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsEmail(string inputData)
    {
        Match m = RegEmail.Match(inputData);
        return m.Success;
    }

    /// <summary>
    /// 邮编有效性
    /// </summary>
    /// <param name="zip">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsValidZip(string zip)
    {
        Regex rx = new Regex(@"^\d{6}$", RegexOptions.None);
        Match m = rx.Match(zip);
        return m.Success;
    }

    /// <summary>
    /// 固定电话有效性
    /// </summary>
    /// <param name="phone">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsValidPhone(string phone)
    {
        Regex rx = new Regex(@"^(\(\d{3,4}\)|\d{3,4}-)?\d{7,8}$", RegexOptions.None);
        Match m = rx.Match(phone);
        return m.Success;
    }

    /// <summary>
    /// 手机有效性
    /// </summary>
    /// <param name="mobile">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsValidMobile(string mobile)
    {
        Regex rx = new Regex(@"^(13|15)\d{9}$", RegexOptions.None);
        Match m = rx.Match(mobile);
        return m.Success;
    }

    /// <summary>
    /// 电话有效性（固话和手机 ）
    /// </summary>
    /// <param name="number">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsValidPhoneAndMobile(string number)
    {
        Regex rx = new Regex(@"^(\(\d{3,4}\)|\d{3,4}-)?\d{7,8}$|^(13|15)\d{9}$", RegexOptions.None);
        Match m = rx.Match(number);
        return m.Success;
    }

    /// <summary>
    /// Url有效性
    /// </summary>
    /// <param name="url">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsValidURL(string url)
    {
        return Regex.IsMatch(url,
                             @"^(http|https|ftp)\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(:[a-zA-Z0-9]*)?/?([a-zA-Z0-9\-\._\?\,\'/\\\+&%\$#\=~])*[^\.\,\)\(\s]$");
    }

    /// <summary>
    /// IP有效性
    /// </summary>
    /// <param name="ip">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsValidIP(string ip)
    {
        return Regex.IsMatch(ip, @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$");
    }

    /// <summary>
    /// domain 有效性
    /// </summary>
    /// <param name="host">域名</param>
    /// <returns>返回值</returns>
    public static bool IsValidDomain(string host)
    {
        Regex r = new Regex(@"^\d+$");
        if (host.IndexOf(".") == -1)
        {
            return false;
        }
        return !r.IsMatch(host.Replace(".", string.Empty));
    }

    /// <summary>
    /// 判断是否为base64字符串
    /// </summary>
    /// <param name="str">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsBase64String(string str)
    {
        return Regex.IsMatch(str, @"[A-Za-z0-9\+\/\=]");
    }

    /// <summary>
    /// 验证字符串是否是GUID
    /// </summary>
    /// <param name="guid">字符串</param>
    /// <returns>返回值</returns>
    public static bool IsGuid(string guid)
    {
        if (string.IsNullOrEmpty(guid))
            return false;

        return Regex.IsMatch(guid, "[A-F0-9]{8}(-[A-F0-9]{4}){3}-[A-F0-9]{12}|[A-F0-9]{32}", RegexOptions.IgnoreCase);
    }
    #endregion

    #region 日期检查
    /// <summary>
    /// 判断输入的字符是否为日期
    /// </summary>
    /// <param name="strValue">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsDate(string strValue)
    {
        return Regex.IsMatch(strValue,
                             @"^((\d{2}(([02468][048])|([13579][26]))[\-\/\s]?((((0?[13578])|(1[02]))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\-\/\s]?((0?[1-9])|([1-2][0-9])))))|(\d{2}(([02468][1235679])|([13579][01345789]))[\-\/\s]?((((0?[13578])|(1[02]))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\-\/\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))");
    }

    /// <summary>
    /// 判断输入的字符是否为日期,如2004-07-12 14:25|||1900-01-01 00:00|||9999-12-31 23:59
    /// </summary>
    /// <param name="strValue">输入字符串</param>
    /// <returns>返回值</returns>
    public static bool IsDateHourMinute(string strValue)
    {
        return Regex.IsMatch(strValue,
                             @"^(19[0-9]{2}|[2-9][0-9]{3})-((0(1|3|5|7|8)|10|12)-(0[1-9]|1[0-9]|2[0-9]|3[0-1])|(0(4|6|9)|11)-(0[1-9]|1[0-9]|2[0-9]|30)|(02)-(0[1-9]|1[0-9]|2[0-9]))\x20(0[0-9]|1[0-9]|2[0-3])(:[0-5][0-9]){1}$");
    }
    #endregion

    #region 其他
    /// <summary>
    /// 检查字符串最大长度，返回指定长度的串
    /// </summary>
    /// <param name="inputData">输入字符串</param>
    /// <param name="maxLength">最大长度</param>
    /// <returns>返回值</returns>			
    public static string CheckMathLength(string inputData, int maxLength)
    {
        if (!string.IsNullOrEmpty(inputData))
        {
            inputData = inputData.Trim();
            if (inputData.Length > maxLength) //按最大长度截取字符串
            {
                inputData = inputData.Substring(0, maxLength);
            }
        }
        return inputData;
    }

    /// <summary>
    /// 转换成 HTML code
    /// </summary>
    /// <param name="str">输入字符串</param>
    /// <returns>返回值</returns>
    public static string Encode(string str)
    {
        str = str.Replace("&", "&amp;");
        str = str.Replace("'", "''");
        str = str.Replace("\"", "&quot;");
        str = str.Replace(" ", "&nbsp;");
        str = str.Replace("<", "&lt;");
        str = str.Replace(">", "&gt;");
        str = str.Replace("\n", "<br>");
        return str;
    }

    /// <summary>
    ///解析html成 普通文本
    /// </summary>
    /// <param name="str">输入字符串</param>
    /// <returns>返回值</returns>
    public static string Decode(string str)
    {
        str = str.Replace("<br>", "\n");
        str = str.Replace("&gt;", ">");
        str = str.Replace("&lt;", "<");
        str = str.Replace("&nbsp;", " ");
        str = str.Replace("&quot;", "\"");
        return str;
    }
    #endregion

    #region 过滤html标签 RemoveHTML(string html)
    /// <summary>
    /// 过滤html
    /// </summary>
    /// <param name="html">需要过滤的字符串</param>
    /// <returns>过滤html后的字符串</returns>
    public static string RemoveHTML(string html)
    {
        html = Regex.Replace(html, @"<script[^>]*?>.*?</script>", "", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"<(.[^>]*)>", "", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"([\r\n])[\s]+", "", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"-->", "", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"<!--.*", "", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&(quot|#34);", "\"", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&(amp|#38);", "&", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&(lt|#60);", "<", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&(gt|#62);", ">", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&(nbsp|#160);", " ", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&(iexcl|#161);", "\xa1", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&(cent|#162);", "\xa2", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&(pound|#163);", "\xa3", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&(copy|#169);", "\xa9", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"&#(\d+);", "", RegexOptions.IgnoreCase);
        html = Regex.Replace(html, @"<img[^>]*>;", "", RegexOptions.IgnoreCase);
        html.Replace("<", "");
        html.Replace(">", "");
        html.Replace("\r\n", "");
        //html = HttpContext.Current.Server.HtmlEncode(html).Trim();
        //html = HttpContext.Current.Server.HtmlDecode(html).Trim();
        return html;
    }
    #endregion
}
